నిర్వహించదగిన, స్కేలబుల్, మరియు పరీక్షించదగిన అప్లికేషన్‌లను రూపొందించడానికి జావాస్క్రిప్ట్ మాడ్యూల్ ఆర్కిటెక్చర్ మరియు డిజైన్ ప్యాటర్న్‌లను అన్వేషించండి. ఆచరణాత్మక ఉదాహరణలు మరియు ఉత్తమ పద్ధతులను కనుగొనండి.
జావాస్క్రిప్ట్ మాడ్యూల్ ఆర్కిటెక్చర్: డిజైన్ ప్యాటర్న్ ఇంప్లిమెంటేషన్
ఆధునిక వెబ్ డెవలప్‌మెంట్‌లో కీలకమైన జావాస్క్రిప్ట్, డైనమిక్ మరియు ఇంటరాక్టివ్ యూజర్ అనుభవాలను అందిస్తుంది. అయితే, జావాస్క్రిప్ట్ అప్లికేషన్‌లు సంక్లిష్టంగా మారేకొద్దీ, చక్కగా వ్యవస్థీకరించబడిన కోడ్ అవసరం అత్యంత ముఖ్యమైనది. ఇక్కడే మాడ్యూల్ ఆర్కిటెక్చర్ మరియు డిజైన్ ప్యాటర్న్‌లు అమలులోకి వస్తాయి, ఇవి నిర్వహించదగిన, స్కేలబుల్, మరియు పరీక్షించదగిన అప్లికేషన్‌లను రూపొందించడానికి ఒక మార్గదర్శిని అందిస్తాయి. ఈ గైడ్ వివిధ మాడ్యూల్ ప్యాటర్న్‌ల యొక్క ప్రధాన భావనలు మరియు ఆచరణాత్మక అమలులను వివరిస్తుంది, ఇది మిమ్మల్ని శుభ్రమైన, మరింత దృఢమైన జావాస్క్రిప్ట్ కోడ్‌ను వ్రాయడానికి శక్తివంతం చేస్తుంది.
మాడ్యూల్ ఆర్కిటెక్చర్ ఎందుకు ముఖ్యమైనది
నిర్దిష్ట ప్యాటర్న్‌లలోకి ప్రవేశించే ముందు, మాడ్యూల్ ఆర్కిటెక్చర్ ఎందుకు అవసరమో అర్థం చేసుకోవడం చాలా ముఖ్యం. ఈ క్రింది ప్రయోజనాలను పరిగణించండి:
- సంస్థాగతం (Organization): మాడ్యూల్స్ సంబంధిత కోడ్‌ను ఒకచోట చేర్చుతాయి, తార్కిక నిర్మాణాన్ని ప్రోత్సహిస్తాయి మరియు పెద్ద కోడ్‌బేస్‌లను నావిగేట్ చేయడం మరియు అర్థం చేసుకోవడం సులభం చేస్తాయి.
- నిర్వహణ సౌలభ్యం (Maintainability): ఒక మాడ్యూల్‌లో చేసిన మార్పులు సాధారణంగా అప్లికేషన్‌లోని ఇతర భాగాలను ప్రభావితం చేయవు, ఇది అప్‌డేట్‌లు మరియు బగ్ పరిష్కారాలను సులభతరం చేస్తుంది.
- పునర్వినియోగం (Reusability): మాడ్యూల్స్‌ను వివిధ ప్రాజెక్ట్‌లలో తిరిగి ఉపయోగించుకోవచ్చు, ఇది అభివృద్ధి సమయం మరియు శ్రమను తగ్గిస్తుంది.
- పరీక్షా సామర్థ్యం (Testability): మాడ్యూల్స్ స్వతంత్రంగా మరియు స్వీయ-నియంత్రితంగా రూపొందించబడ్డాయి, ఇది యూనిట్ పరీక్షలను వ్రాయడం సులభతరం చేస్తుంది.
- విస్తరణ సామర్థ్యం (Scalability): మాడ్యూల్స్‌తో నిర్మించిన చక్కటి ఆర్కిటెక్చర్ ఉన్న అప్లికేషన్‌లు ప్రాజెక్ట్ పెరిగేకొద్దీ మరింత సమర్థవంతంగా విస్తరించగలవు.
- సహకారం (Collaboration): మాడ్యూల్స్ బృందకృషిని సులభతరం చేస్తాయి, ఎందుకంటే బహుళ డెవలపర్లు ఒకరి పనిలో మరొకరు జోక్యం చేసుకోకుండా ఏకకాలంలో వివిధ మాడ్యూల్స్‌పై పనిచేయవచ్చు.
జావాస్క్రిప్ట్ మాడ్యూల్ సిస్టమ్స్: ఒక అవలోకనం
జావాస్క్రిప్ట్‌లో మాడ్యులారిటీ అవసరాన్ని పరిష్కరించడానికి అనేక మాడ్యూల్ సిస్టమ్‌లు అభివృద్ధి చెందాయి. డిజైన్ ప్యాటర్న్‌లను సమర్థవంతంగా వర్తింపజేయడానికి ఈ సిస్టమ్‌లను అర్థం చేసుకోవడం చాలా ముఖ్యం.
కామన్‌జెఎస్ (CommonJS)
Node.js పరిసరాలలో ప్రబలమైన కామన్‌జెఎస్, మాడ్యూల్స్‌ను దిగుమతి చేసుకోవడానికి require() మరియు వాటిని ఎగుమతి చేయడానికి module.exports లేదా exportsను ఉపయోగిస్తుంది. ఇది ఒక సింక్రోనస్ మాడ్యూల్ లోడింగ్ సిస్టమ్.
// myModule.js
module.exports = {
myFunction: function() {
console.log('Hello from myModule!');
}
};
// app.js
const myModule = require('./myModule');
myModule.myFunction();
వినియోగ సందర్భాలు: ప్రధానంగా సర్వర్-సైడ్ జావాస్క్రిప్ట్ (Node.js)లో మరియు కొన్నిసార్లు ఫ్రంట్-ఎండ్ ప్రాజెక్ట్‌ల కోసం బిల్డ్ ప్రాసెస్‌లలో ఉపయోగించబడుతుంది.
ఏఎండి (అసింక్రోనస్ మాడ్యూల్ డెఫినిషన్ - AMD)
ఏఎండి అసింక్రోనస్ మాడ్యూల్ లోడింగ్ కోసం రూపొందించబడింది, ఇది వెబ్ బ్రౌజర్‌లకు అనుకూలంగా ఉంటుంది. ఇది మాడ్యూల్స్‌ను ప్రకటించడానికి define() మరియు వాటిని దిగుమతి చేసుకోవడానికి require()ను ఉపయోగిస్తుంది. RequireJS వంటి లైబ్రరీలు ఏఎండిని అమలు చేస్తాయి.
// myModule.js (using RequireJS syntax)
define(function() {
return {
myFunction: function() {
console.log('Hello from myModule (AMD)!');
}
};
});
// app.js (using RequireJS syntax)
require(['./myModule'], function(myModule) {
myModule.myFunction();
});
వినియోగ సందర్భాలు: చారిత్రాత్మకంగా బ్రౌజర్-ఆధారిత అప్లికేషన్‌లలో, ముఖ్యంగా డైనమిక్ లోడింగ్ లేదా బహుళ డిపెండెన్సీలతో వ్యవహరించే వాటిలో ఉపయోగించబడింది.
ఈఎస్ మాడ్యూల్స్ (ESM)
ఈఎస్ మాడ్యూల్స్, అధికారికంగా ECMAScript స్టాండర్డ్‌లో భాగంగా, ఒక ఆధునిక మరియు ప్రామాణికమైన విధానాన్ని అందిస్తాయి. అవి మాడ్యూల్స్‌ను దిగుమతి చేసుకోవడానికి import మరియు వాటిని ఎగుమతి చేయడానికి export (export default)ను ఉపయోగిస్తాయి. ఈఎస్ మాడ్యూల్స్ ఇప్పుడు ఆధునిక బ్రౌజర్‌లు మరియు Node.js ద్వారా విస్తృతంగా మద్దతు ఇవ్వబడుతున్నాయి.
// myModule.js
export function myFunction() {
console.log('Hello from myModule (ESM)!');
}
// app.js
import { myFunction } from './myModule.js';
myFunction();
వినియోగ సందర్భాలు: ఆధునిక జావాస్క్రిప్ట్ అభివృద్ధికి ప్రాధాన్యత ఇవ్వబడిన మాడ్యూల్ సిస్టమ్, ఇది బ్రౌజర్ మరియు సర్వర్-సైడ్ పరిసరాలకు మద్దతు ఇస్తుంది మరియు ట్రీ-షేకింగ్ ఆప్టిమైజేషన్‌ను ప్రారంభిస్తుంది.
జావాస్క్రిప్ట్ మాడ్యూల్స్ కోసం డిజైన్ ప్యాటర్న్స్
సింగిల్‌టన్‌లను సృష్టించడం, ఈవెంట్‌లను నిర్వహించడం లేదా విభిన్న కాన్ఫిగరేషన్‌లతో ఆబ్జెక్ట్‌లను సృష్టించడం వంటి నిర్దిష్ట లక్ష్యాలను సాధించడానికి జావాస్క్రిప్ట్ మాడ్యూల్స్‌కు అనేక డిజైన్ ప్యాటర్న్‌లను వర్తింపజేయవచ్చు. మేము సాధారణంగా ఉపయోగించే కొన్ని ప్యాటర్న్‌లను ఆచరణాత్మక ఉదాహరణలతో అన్వేషిస్తాము.
1. సింగిల్‌టన్ ప్యాటర్న్ (The Singleton Pattern)
సింగిల్‌టన్ ప్యాటర్న్ అప్లికేషన్ యొక్క జీవితచక్రంలో ఒక క్లాస్ లేదా ఆబ్జెక్ట్ యొక్క ఒకే ఒక ఇన్‌స్టాన్స్ సృష్టించబడిందని నిర్ధారిస్తుంది. ఇది డేటాబేస్ కనెక్షన్ లేదా గ్లోబల్ కాన్ఫిగరేషన్ ఆబ్జెక్ట్ వంటి వనరులను నిర్వహించడానికి ఉపయోగపడుతుంది.
// Using an immediately invoked function expression (IIFE) to create the singleton
const singleton = (function() {
let instance;
function createInstance() {
const object = new Object({ name: 'Singleton Instance' });
return object;
}
return {
getInstance: function() {
if (!instance) {
instance = createInstance();
}
return instance;
},
};
})();
// Usage
const instance1 = singleton.getInstance();
const instance2 = singleton.getInstance();
console.log(instance1 === instance2); // Output: true
console.log(instance1.name); // Output: Singleton Instance
వివరణ:
- ఒక IIFE (వెంటనే ప్రారంభమయ్యే ఫంక్షన్ ఎక్స్‌ప్రెషన్) ఒక ప్రైవేట్ స్కోప్‌ను సృష్టిస్తుంది, ఇది `instance` యొక్క ప్రమాదవశాత్తు మార్పును నిరోధిస్తుంది.
- `getInstance()` పద్ధతి కేవలం ఒకే ఒక ఇన్‌స్టాన్స్ మాత్రమే సృష్టించబడిందని నిర్ధారిస్తుంది. మొదటిసారి పిలిచినప్పుడు, అది ఇన్‌స్టాన్స్‌ను సృష్టిస్తుంది. తదుపరి పిలుపులు ఇప్పటికే ఉన్న ఇన్‌స్టాన్స్‌ను తిరిగి ఇస్తాయి.
వినియోగ సందర్భాలు: గ్లోబల్ కాన్ఫిగరేషన్ సెట్టింగ్‌లు, లాగింగ్ సేవలు, డేటాబేస్ కనెక్షన్‌లు మరియు అప్లికేషన్ స్థితిని నిర్వహించడం.
2. ఫ్యాక్టరీ ప్యాటర్న్ (The Factory Pattern)
ఫ్యాక్టరీ ప్యాటర్న్ ఆబ్జెక్ట్‌లను వాటి కాంక్రీట్ క్లాస్‌లను పేర్కొనకుండా సృష్టించడానికి ఒక ఇంటర్‌ఫేస్‌ను అందిస్తుంది. ఇది నిర్దిష్ట ప్రమాణాలు లేదా కాన్ఫిగరేషన్‌ల ఆధారంగా ఆబ్జెక్ట్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇది ఫ్లెక్సిబిలిటీ మరియు కోడ్ పునర్వినియోగాన్ని ప్రోత్సహిస్తుంది.
// Factory function
function createCar(type, options) {
switch (type) {
case 'sedan':
return new Sedan(options);
case 'suv':
return new SUV(options);
default:
return null;
}
}
// Car classes (implementation)
class Sedan {
constructor(options) {
this.type = 'Sedan';
this.color = options.color || 'white';
this.model = options.model || 'Unknown';
}
getDescription() {
return `This is a ${this.color} ${this.model} Sedan.`
}
}
class SUV {
constructor(options) {
this.type = 'SUV';
this.color = options.color || 'black';
this.model = options.model || 'Unknown';
}
getDescription() {
return `This is a ${this.color} ${this.model} SUV.`
}
}
// Usage
const mySedan = createCar('sedan', { color: 'blue', model: 'Camry' });
const mySUV = createCar('suv', { model: 'Explorer' });
console.log(mySedan.getDescription()); // Output: This is a blue Camry Sedan.
console.log(mySUV.getDescription()); // Output: This is a black Explorer SUV.
వివరణ:
- `createCar()` ఫంక్షన్ ఫ్యాక్టరీగా పనిచేస్తుంది.
- ఇది `type` మరియు `options`ను ఇన్‌పుట్‌గా తీసుకుంటుంది.
- `type` ఆధారంగా, ఇది సంబంధిత కార్ క్లాస్ యొక్క ఇన్‌స్టాన్స్‌ను సృష్టించి తిరిగి ఇస్తుంది.
వినియోగ సందర్భాలు: విభిన్న కాన్ఫిగరేషన్‌లతో సంక్లిష్ట ఆబ్జెక్ట్‌లను సృష్టించడం, సృష్టి ప్రక్రియను సంగ్రహించడం మరియు ఇప్పటికే ఉన్న కోడ్‌ను మార్చకుండా కొత్త ఆబ్జెక్ట్ రకాలను సులభంగా జోడించడానికి అనుమతించడం.
3. అబ్జర్వర్ ప్యాటర్న్ (The Observer Pattern)
అబ్జర్వర్ ప్యాటర్న్ ఆబ్జెక్ట్‌ల మధ్య ఒకటి-నుండి-అనేకం డిపెండెన్సీని నిర్వచిస్తుంది. ఒక ఆబ్జెక్ట్ (సబ్జెక్ట్) స్థితి మారినప్పుడు, దాని డిపెండెంట్లు (అబ్జర్వర్లు) అన్నీ తెలియజేయబడతాయి మరియు స్వయంచాలకంగా అప్‌డేట్ చేయబడతాయి. ఇది డీకప్లింగ్ మరియు ఈవెంట్-ఆధారిత ప్రోగ్రామింగ్‌ను సులభతరం చేస్తుంది.
class Subject {
constructor() {
this.observers = [];
}
subscribe(observer) {
this.observers.push(observer);
}
unsubscribe(observer) {
this.observers = this.observers.filter(obs => obs !== observer);
}
notify(data) {
this.observers.forEach(observer => observer.update(data));
}
}
class Observer {
constructor(name) {
this.name = name;
}
update(data) {
console.log(`${this.name} received: ${data}`);
}
}
// Usage
const subject = new Subject();
const observer1 = new Observer('Observer 1');
const observer2 = new Observer('Observer 2');
subject.subscribe(observer1);
subject.subscribe(observer2);
subject.notify('Hello, observers!'); // Observer 1 received: Hello, observers! Observer 2 received: Hello, observers!
subject.unsubscribe(observer1);
subject.notify('Another update!'); // Observer 2 received: Another update!
వివరణ:
- `Subject` క్లాస్ అబ్జర్వర్లను (సబ్‌స్క్రైబర్‌లను) నిర్వహిస్తుంది.
- `subscribe()` మరియు `unsubscribe()` పద్ధతులు అబ్జర్వర్లు నమోదు చేసుకోవడానికి మరియు నమోదును రద్దు చేసుకోవడానికి అనుమతిస్తాయి.
- `notify()` ప్రతి నమోదిత అబ్జర్వర్ యొక్క `update()` పద్ధతిని పిలుస్తుంది.
- `Observer` క్లాస్ మార్పులకు ప్రతిస్పందించే `update()` పద్ధతిని నిర్వచిస్తుంది.
వినియోగ సందర్భాలు: యూజర్ ఇంటర్‌ఫేస్‌లలో ఈవెంట్ హ్యాండ్లింగ్, రియల్-టైమ్ డేటా అప్‌డేట్‌లు మరియు అసింక్రోనస్ ఆపరేషన్‌లను నిర్వహించడం. ఉదాహరణకు, డేటా మారినప్పుడు UI ఎలిమెంట్‌లను అప్‌డేట్ చేయడం (ఉదాహరణకు, నెట్‌వర్క్ అభ్యర్థన నుండి), అంతర్-భాగాల కమ్యూనికేషన్ కోసం పబ్/సబ్ సిస్టమ్‌ను అమలు చేయడం, లేదా అప్లికేషన్‌లోని ఒక భాగంలో మార్పులు ఇతర చోట్ల అప్‌డేట్‌లను ప్రేరేపించే రియాక్టివ్ సిస్టమ్‌ను నిర్మించడం.
4. మాడ్యూల్ ప్యాటర్న్ (The Module Pattern)
మాడ్యూల్ ప్యాటర్న్ స్వతంత్ర, పునర్వినియోగ కోడ్ బ్లాక్‌లను సృష్టించడానికి ఒక ప్రాథమిక టెక్నిక్. ఇది పబ్లిక్ మరియు ప్రైవేట్ సభ్యులను ఎన్‌క్యాప్సులేట్ చేస్తుంది, నేమింగ్ ఘర్షణలను నివారిస్తుంది మరియు సమాచార దాచిపెట్టడాన్ని ప్రోత్సహిస్తుంది. ఇది తరచుగా ఒక ప్రైవేట్ స్కోప్‌ను సృష్టించడానికి ఒక IIFE (వెంటనే ప్రారంభమయ్యే ఫంక్షన్ ఎక్స్‌ప్రెషన్)ను ఉపయోగిస్తుంది.
const myModule = (function() {
// Private variables and functions
let privateVariable = 'Hello';
function privateFunction() {
console.log('This is a private function.');
}
// Public interface
return {
publicMethod: function() {
console.log(privateVariable);
privateFunction();
},
publicVariable: 'World'
};
})();
// Usage
myModule.publicMethod(); // Output: Hello This is a private function.
console.log(myModule.publicVariable); // Output: World
// console.log(myModule.privateVariable); // Error: privateVariable is not defined (accessing private variables is not allowed)
వివరణ:
- ఒక IIFE ఒక క్లోజర్‌ను సృష్టిస్తుంది, మాడ్యూల్ యొక్క అంతర్గత స్థితిని ఎన్‌క్యాప్సులేట్ చేస్తుంది.
- IIFE లోపల ప్రకటించబడిన వేరియబుల్స్ మరియు ఫంక్షన్లు ప్రైవేట్‌గా ఉంటాయి.
- `return` స్టేట్‌మెంట్ పబ్లిక్ ఇంటర్‌ఫేస్‌ను బహిర్గతం చేస్తుంది, ఇందులో మాడ్యూల్ వెలుపల నుండి యాక్సెస్ చేయగల పద్ధతులు మరియు వేరియబుల్స్ ఉంటాయి.
వినియోగ సందర్భాలు: కోడ్‌ను నిర్వహించడం, పునర్వినియోగ భాగాలను సృష్టించడం, లాజిక్‌ను ఎన్‌క్యాప్సులేట్ చేయడం మరియు నేమింగ్ ఘర్షణలను నివారించడం. ఇది అనేక పెద్ద ప్యాటర్న్‌ల యొక్క ప్రధాన బిల్డింగ్ బ్లాక్, తరచుగా సింగిల్‌టన్ లేదా ఫ్యాక్టరీ ప్యాటర్న్‌ల వంటి ఇతర ప్యాటర్న్‌లతో కలిపి ఉపయోగించబడుతుంది.
5. రివీలింగ్ మాడ్యూల్ ప్యాటర్న్ (Revealing Module Pattern)
మాడ్యూల్ ప్యాటర్న్ యొక్క ఒక వైవిధ్యం, రివీలింగ్ మాడ్యూల్ ప్యాటర్న్ తిరిగి ఇవ్వబడిన ఆబ్జెక్ట్ ద్వారా కేవలం నిర్దిష్ట సభ్యులను మాత్రమే బహిర్గతం చేస్తుంది, అమలు వివరాలను దాచి ఉంచుతుంది. ఇది మాడ్యూల్ యొక్క పబ్లిక్ ఇంటర్‌ఫేస్‌ను స్పష్టంగా మరియు సులభంగా అర్థం చేసుకోవడానికి సహాయపడుతుంది.
const revealingModule = (function() {
let privateVariable = 'Secret Message';
function privateFunction() {
console.log('Inside privateFunction');
}
function publicGet() {
return privateVariable;
}
function publicSet(value) {
privateVariable = value;
}
// Reveal public members
return {
get: publicGet,
set: publicSet,
// You can also reveal privateFunction (but usually it is hidden)
// show: privateFunction
};
})();
// Usage
console.log(revealingModule.get()); // Output: Secret Message
revealingModule.set('New Secret');
console.log(revealingModule.get()); // Output: New Secret
// revealingModule.privateFunction(); // Error: revealingModule.privateFunction is not a function
వివరణ:
- ప్రైవేట్ వేరియబుల్స్ మరియు ఫంక్షన్లు సాధారణంగా ప్రకటించబడతాయి.
- పబ్లిక్ పద్ధతులు నిర్వచించబడతాయి, మరియు అవి ప్రైవేట్ సభ్యులను యాక్సెస్ చేయగలవు.
- తిరిగి ఇవ్వబడిన ఆబ్జెక్ట్ పబ్లిక్ ఇంటర్‌ఫేస్‌ను ప్రైవేట్ అమలులకు స్పష్టంగా మ్యాప్ చేస్తుంది.
వినియోగ సందర్భాలు: మాడ్యూల్స్ యొక్క ఎన్‌క్యాప్సులేషన్‌ను మెరుగుపరచడం, శుభ్రమైన మరియు కేంద్రీకృత పబ్లిక్ APIని అందించడం మరియు మాడ్యూల్ యొక్క వినియోగాన్ని సులభతరం చేయడం. తరచుగా లైబ్రరీ డిజైన్‌లో కేవలం అవసరమైన ఫంక్షనాలిటీలను మాత్రమే బహిర్గతం చేయడానికి ఉపయోగించబడుతుంది.
6. డెకరేటర్ ప్యాటర్న్ (The Decorator Pattern)
డెకరేటర్ ప్యాటర్న్ ఒక ఆబ్జెక్ట్ యొక్క నిర్మాణాన్ని మార్చకుండా డైనమిక్‌గా దానికి కొత్త బాధ్యతలను జోడిస్తుంది. ఇది అసలు ఆబ్జెక్ట్‌ను ఒక డెకరేటర్ ఆబ్జెక్ట్‌లో చుట్టడం ద్వారా సాధించబడుతుంది. ఇది సబ్‌క్లాసింగ్‌కు ఒక ఫ్లెక్సిబుల్ ప్రత్యామ్నాయాన్ని అందిస్తుంది, రన్‌టైమ్‌లో ఫంక్షనాలిటీని విస్తరించడానికి మిమ్మల్ని అనుమతిస్తుంది.
// Component interface (base object)
class Pizza {
constructor() {
this.description = 'Plain Pizza';
}
getDescription() {
return this.description;
}
getCost() {
return 10;
}
}
// Decorator abstract class
class PizzaDecorator extends Pizza {
constructor(pizza) {
super();
this.pizza = pizza;
}
getDescription() {
return this.pizza.getDescription();
}
getCost() {
return this.pizza.getCost();
}
}
// Concrete Decorators
class CheeseDecorator extends PizzaDecorator {
constructor(pizza) {
super(pizza);
this.description = 'Cheese Pizza';
}
getDescription() {
return `${this.pizza.getDescription()}, Cheese`;
}
getCost() {
return this.pizza.getCost() + 2;
}
}
class PepperoniDecorator extends PizzaDecorator {
constructor(pizza) {
super(pizza);
this.description = 'Pepperoni Pizza';
}
getDescription() {
return `${this.pizza.getDescription()}, Pepperoni`;
}
getCost() {
return this.pizza.getCost() + 3;
}
}
// Usage
let pizza = new Pizza();
pizza = new CheeseDecorator(pizza);
pizza = new PepperoniDecorator(pizza);
console.log(pizza.getDescription()); // Output: Plain Pizza, Cheese, Pepperoni
console.log(pizza.getCost()); // Output: 15
వివరణ:
- `Pizza` క్లాస్ బేస్ ఆబ్జెక్ట్.
- `PizzaDecorator` అనేది అబ్‌స్ట్రాక్ట్ డెకరేటర్ క్లాస్. ఇది `Pizza` క్లాస్‌ను విస్తరించి, ఒక `pizza` ప్రాపర్టీని (చుట్టబడిన ఆబ్జెక్ట్) కలిగి ఉంటుంది.
- కాంక్రీట్ డెకరేటర్లు (ఉదా., `CheeseDecorator`, `PepperoniDecorator`) `PizzaDecorator`ను విస్తరించి నిర్దిష్ట ఫంక్షనాలిటీని జోడిస్తాయి. అవి తమ సొంత ఫీచర్‌లను జోడించడానికి `getDescription()` మరియు `getCost()` పద్ధతులను ఓవర్‌రైడ్ చేస్తాయి.
- క్లయింట్ బేస్ ఆబ్జెక్ట్ యొక్క నిర్మాణాన్ని మార్చకుండా డైనమిక్‌గా డెకరేటర్‌లను జోడించవచ్చు.
వినియోగ సందర్భాలు: ఆబ్జెక్ట్‌లకు డైనమిక్‌గా ఫీచర్‌లను జోడించడం, అసలు ఆబ్జెక్ట్ క్లాస్‌ను మార్చకుండా ఫంక్షనాలిటీని విస్తరించడం మరియు సంక్లిష్ట ఆబ్జెక్ట్ కాన్ఫిగరేషన్‌లను నిర్వహించడం. UI మెరుగుదలలు, ఇప్పటికే ఉన్న ఆబ్జెక్ట్‌లకు వాటి ప్రధాన అమలును మార్చకుండా ప్రవర్తనలను జోడించడం (ఉదా., లాగింగ్, సెక్యూరిటీ తనిఖీలు లేదా పనితీరు పర్యవేక్షణ) కోసం ఉపయోగపడుతుంది.
వివిధ పరిసరాలలో మాడ్యూల్స్‌ను అమలు చేయడం
మాడ్యూల్ సిస్టమ్ యొక్క ఎంపిక అభివృద్ధి వాతావరణం మరియు లక్ష్య ప్లాట్‌ఫారమ్‌పై ఆధారపడి ఉంటుంది. వివిధ దృశ్యాలలో మాడ్యూల్స్‌ను ఎలా అమలు చేయాలో చూద్దాం.
1. బ్రౌజర్-ఆధారిత అభివృద్ధి
బ్రౌజర్‌లో, మీరు సాధారణంగా ఈఎస్ మాడ్యూల్స్ లేదా ఏఎండిని ఉపయోగిస్తారు.
- ఈఎస్ మాడ్యూల్స్: ఆధునిక బ్రౌజర్‌లు ఇప్పుడు ఈఎస్ మాడ్యూల్స్‌కు స్థానికంగా మద్దతు ఇస్తాయి. మీరు మీ జావాస్క్రిప్ట్ ఫైల్‌లలో `import` మరియు `export` సింటాక్స్‌ను ఉపయోగించవచ్చు మరియు `